import { useState, useEffect, useRef, useCallback } from 'react';

interface SpeechRecognitionHook {
  isListening: boolean;
  transcript: string;
  error: string | null;
  startListening: () => void;
  stopListening: () => void;
  resetTranscript: () => void;
}

export const useSpeechRecognition = (): SpeechRecognitionHook => {
  const [isListening, setIsListening] = useState(false);
  const [transcript, setTranscript] = useState('');
  const [error, setError] = useState<string | null>(null);
  const recognitionRef = useRef<any>(null);

  const startListening = useCallback(() => {
    // 检查浏览器是否支持语音识别
    const SpeechRecognition =
      (window as any).SpeechRecognition || (window as any).webkitSpeechRecognition;

    if (!SpeechRecognition) {
      setError('您的浏览器不支持语音识别功能');
      return;
    }

    try {
      const recognition = new SpeechRecognition();
      recognition.continuous = true; // 连续识别
      recognition.interimResults = true; // 返回中间结果
      recognition.lang = 'zh-CN'; // 设置为中文

      recognition.onstart = () => {
        setIsListening(true);
        // 成功启动时，只清除非关键错误（如"未检测到语音"等临时错误）
        // 保留网络错误和权限错误等重要错误
        setError((prevError) => {
          if (prevError && (prevError.includes('网络') || prevError.includes('权限') || prevError.includes('浏览器不支持'))) {
            return prevError; // 保留重要错误
          }
          return null; // 清除临时错误
        });
      };

      recognition.onresult = (event: any) => {
        let interimTranscript = '';
        let finalTranscript = '';

        for (let i = event.resultIndex; i < event.results.length; i++) {
          const transcript = event.results[i][0].transcript;
          if (event.results[i].isFinal) {
            finalTranscript += transcript;
          } else {
            interimTranscript += transcript;
          }
        }

        setTranscript(finalTranscript || interimTranscript);
      };


      let hasError = false;
      
      recognition.onerror = (event: any) => {
        console.error('Speech recognition error:', event);
        setIsListening(false);
        hasError = true; // 标记有错误发生
        
        // 根据错误类型设置友好的错误消息
        let errorMessage = '';
        switch (event.error) {
          case 'no-speech':
            errorMessage = '未检测到语音，请重试';
            break;
          case 'audio-capture':
            errorMessage = '无法访问麦克风，请检查权限';
            break;
          case 'not-allowed':
            errorMessage = '麦克风权限被拒绝，请在浏览器设置中允许';
            break;
          case 'network':
            errorMessage = '网络连接错误，请检查网络连接。语音识别需要稳定的网络连接，如果使用Chrome浏览器，请确保可以访问Google服务';
            break;
          case 'aborted':
            errorMessage = '语音识别已取消';
            break;
          case 'service-not-allowed':
            errorMessage = '浏览器不允许使用语音识别服务，请检查浏览器设置';
            break;
          default:
            errorMessage = `识别错误: ${event.error}`;
        }
        
        setError(errorMessage);
        
        // 对于网络错误，尝试重新初始化识别器
        if (event.error === 'network') {
          console.warn('语音识别网络错误，将在3秒后自动清理...');
          setTimeout(() => {
            // 清理旧的识别器
            if (recognitionRef.current) {
              try {
                recognitionRef.current.abort();
              } catch {
                // 忽略清理错误
              }
            }
            // 注意：这里不自动重试，让用户手动重试
          }, 3000);
        }
      };
      
      recognition.onend = () => {
        setIsListening(false);
        // 如果没有错误，正常结束，可以清除临时错误
        // 但网络错误等重要错误应该保持
        if (!hasError) {
          // 正常结束，延迟清除临时错误（避免与错误处理冲突）
          setTimeout(() => {
            setError((prevError) => {
              // 只清除非网络错误
              if (prevError && prevError.includes('网络')) {
                return prevError; // 保持网络错误
              }
              return null;
            });
          }, 1000);
        }
      };

      // 在启动前清除之前的非关键错误
      setError((prevError) => {
        // 保留网络错误等重要错误
        if (prevError && (prevError.includes('网络') || prevError.includes('权限'))) {
          hasError = true;
          return prevError;
        }
        return null;
      });

      recognitionRef.current = recognition;
      recognition.start();
    } catch (err: any) {
      setError(err.message || '启动语音识别失败');
      setIsListening(false);
    }
  }, []);

  const stopListening = useCallback(() => {
    if (recognitionRef.current) {
      recognitionRef.current.stop();
      setIsListening(false);
    }
  }, []);

  const resetTranscript = useCallback(() => {
    setTranscript('');
    setError(null);
  }, []);

  // 组件卸载时清理
  useEffect(() => {
    return () => {
      if (recognitionRef.current) {
        recognitionRef.current.abort();
      }
    };
  }, []);

  return {
    isListening,
    transcript,
    error,
    startListening,
    stopListening,
    resetTranscript,
  };
};

